home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / Anwendun / 7UP_PD / VAFUNC.H < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-07  |  9.4 KB  |  328 lines
  1. /********************************************************************/
  2. /* Funktionsprototypen für Funktionen, die die Kommunikation mit
  3.    GEMINI bzw. Venus vereinfachen
  4.  
  5.    (c) 1990,91,92 by Stephan Gerle
  6.  
  7.    E-Mail: Maus Net: Stephan Gerle @ DO
  8.            Internet: sg@do.maus.de
  9.  
  10.    Stand: 8.3.92
  11.  
  12.    Sämtliche Funktionen liefern 1, wenn die Hauptapplikation die
  13.    Funktion kennt bzw. 0, wenn die Hauptapplikation die Funktion
  14.    nicht kennt.
  15.  
  16.    Die Funktionen wurden komplett umgeschrieben, da es erhebliche
  17.    Probleme mit dem Timeout gab.
  18.    Da das AV-Protokoll Event-orientiert arbeitet, ist die Realisierung
  19.    einiger Funktionen als Funktion nicht möglich bzw. führt nur
  20.    zu Problemen.
  21.  
  22.    Siehe auch VAPROTO.H.
  23.  
  24.    Achtung: 5er Tabs
  25. */
  26.  
  27. #ifndef __VAFUNC_H
  28. #define __VAFUNC_H
  29.  
  30. #include <sg\vaproto.h>
  31.  
  32. /*** Macros **********************************************************/
  33.  
  34. /* AVSTR2MSG setzt den Wert eines String-Pointers in ein Message-
  35.    array ein.
  36.        msg    : Name des Integerarrays.
  37.        offset : Kleinerer Index des Interger-Pärchens
  38.        str    : Zeiger auf String
  39. */
  40. #define  AVSTR2MSG(msg,offset,str)  (*(char **)(msg+offset) = str)
  41.  
  42. /* AVMSG2STR bastelt aus einem Integer-Pärchens einer Messages einen
  43.    String-Pointer zusammen.
  44.        msg    : Name des Integerarrays
  45.        offset : Kleinerer Index des Integer-Pärchens.
  46. */
  47. #define  AVMSG2STR(msg,offset)         ((char *)(((long)msg[offset]<<16)|(((long)msg[offset+1])&0xffff)))
  48.  
  49. /* AVHasProto() dient zum Test, ob die Hauptapplikation eine bestimmte
  50.    Funktion des AV-Protokolls unterstützt.
  51.    Als Parameter wird die Nummer des Words (0-2) sowie die Bitnummer
  52.    im Word übergeben.
  53.    Näheres hierzu siehe VAPROTO.H bei VA_PROTOSTATUS */
  54.  
  55. #define  AVHasProto(word,bit)       (AVStatus[word]&(1<<bit))
  56.  
  57.  
  58. /* Liefert TRUE, wenn eine MultiTasking fähiges AES installiert ist.
  59. */
  60.  
  61. #define  MultiAES()  (_GemParBlk.global[1]!=1)
  62.  
  63. #define    AP_TERM    50
  64.  
  65. /*** Globale Variablen für die Library für das AV-Protokoll **********/
  66.  
  67.  
  68.  
  69. /* AVName ist ein Pointer auf einen String, in dem der Name der
  70.    Hauptapplikation steht, die das AV-Protokoll beherrscht.
  71.    Diese Variable wird durch AVActive gesetzt. Der String ist ein
  72.    Leerstring, wenn das Hauptprogramm das AV-Protokoll nicht versteht.*/
  73.  
  74. extern char AVName[];
  75.  
  76. /* AVStatus[3] enthält den Protokollstatus der Hauptapplikation.
  77.    Mittels AVHasProto(word,bit) kann damit jede einzelne Funktion des
  78.    AV-Protokolls überprüft werden. */
  79.  
  80. extern int  AVStatus[3];
  81.  
  82.  
  83. /*** Funktionen für die Protokollunterstützung ***********************/
  84.  
  85.  
  86. /* AVInit muß einmal beim Start des Acc's aufgerufen werden. Damit
  87.    wird die Applikationsid, der Name des Acc (wie bei appl_find benutzt;
  88.    also 8 des Programmnamens eventuell mit Leerzeichen aufgefüllt) sowie
  89.    die vom Acc unterstützten Funktionen als Bitvektor den Funktionen
  90.    für das AV-Protokoll übergeben.
  91.    Diese Routine sollte direkt vor Eintritt in die Messageloop
  92.    aufgerufen werden. */
  93.  
  94. void  AVInit(int myapid,char *myname,int myprotostatus);
  95.  
  96.  
  97. /* Ermittelt, ob Gemini oder Venus bzw. irgendein Hauptprogramm,
  98.    welches das AV-Protokoll versteht, aktiv ist.
  99.    Wenn nein, so wird 0 zurückgeliefert, sonst ein Wert ungleich 0.
  100.    Falls der Protokollstatus noch nicht ermittelt werden konnte, so
  101.    wird eine entsprechende Message an das Hauptprogramm geschickt.
  102.    Das Ergebnis ist dann ersteinmal 0. */
  103.  
  104. int   AVActive(void);
  105.  
  106.  
  107. /* Sorgt dafür, das der AV-Protokoll-Status neu ermittelt wird. Diese
  108.    Funktion wird bei einem AC_CLOSE durch AVProcessMsg() automatisch
  109.    aufgerufen. */
  110.  
  111. void  AVGetNewProtoStatus(void);
  112.  
  113.  
  114. /* Sendet Statusinformationen an die Hauptapplikation. */
  115.  
  116. int   AVSendStatus(char *status);
  117.  
  118.  
  119. /* Fragt bei der Hauptapplikation den für das Acc gespeicherten Status
  120.    nach.
  121.    Als Antwort kommt von der Hauptapplikation die Meldung VA_SETSTATUS.
  122.    Ansonsten muß die Meldung VA_SETSTATUS in der Messageloop behandelt
  123.    werden. In msg[3/4] ist ein Pointer auf einen String, der den
  124.    Status enthält. */
  125.  
  126. void  AVReceiveStatus(void);
  127.  
  128.  
  129. /* AVProcessMsg muss für jede empfangene Message aufgerufen werden.
  130.    AVProcessMsg liefert einen Wert ungleich 0, falls sich der
  131.    Protokollstatus geändert hat. Das heißt aber nicht, das die
  132.    Nachricht VA_PROTOSTATUS gekommen ist!!! */
  133.  
  134. int   AVProcessMsg(int *msg);
  135.  
  136.  
  137.  
  138. /*** Programmspezifische Funktionen *********************************/
  139.  
  140.  
  141.  
  142. /* Emittelt den für Verzeichnisfenster eingestellten Font und die
  143.    Fonthöhe.
  144.    Die Hauptapplikation schickt daraufhin die Message VA_FILEFONT. */
  145.  
  146. int   AVAskFileFont(void);
  147.  
  148.  
  149. /* Dasselbe wie AVAskFileFont, nur für das Console-Fenster.
  150.    Als Ergebnis kommt die Message VA_CONFONT. */
  151.  
  152. int   AVAskConsoleFont(void);
  153.  
  154.  
  155. /* Fragt bei der Hauptapplikation nach den selektierten Objekten.
  156.    Als Antwort kommt die Message VA_OBJECT. Die Objekte sind jeweils
  157.    durch ein ' ' im String voneinander getrennt. */
  158.  
  159. void  AVAskSelectedObjects(void);
  160.  
  161.  
  162. /* Sagt Gemini, daß das Console-Fenster geöffnet werden soll. */
  163.  
  164. int   AVOpenConsole(void);
  165.  
  166.  
  167. /* Sagt der Hauptapplikation, das ein Fenster mit dem Verzeichnis
  168.    pfad und der Maske mask geöffnet werden soll. */
  169.  
  170. int   AVOpenWindow(char *pfad,char *mask);
  171.  
  172.  
  173. /* Startet mittels Venus bzw. Gemini ein Programm. In pfad steht
  174.    der komplette Pfad und der Programmname. cmdline enthält
  175.    die Kommandozeile für das zu startende Programm. */
  176.  
  177. int   AVStartProgram(char *pfad,char *cmdline);
  178.  
  179.  
  180. /* Sagt der Hauptapplikation, daß das Accessorie ein Fenster geöffnet hat.
  181.  */
  182.  
  183. int   AVAccOpenedWindow(int winhandle);
  184.  
  185.  
  186. /* Sagt der Hauptapplikation, daß das Accessorie ein Fenster geschlossen
  187.  hat.
  188.    (ist nur bei nicht durch AC_CLOSE bedingtem Schließen notwendig) */
  189.  
  190. int   AVAccClosedWindow(int winhandle);
  191.  
  192.  
  193. /* Schickt der Hauptapplikation einen Tastaturevent. Ist dann anzuwenden,
  194.    wenn ein ACC ein Fenster offen hat, und einen Tastendruck bekommt,
  195.    den es selber nicht verwendet. */
  196.  
  197. int   AVSendKeyEvent(int state,int key);
  198.  
  199.  
  200. /* AVCopyDragged schickt die Message AV_COPY_DRAGGED an die
  201.  Hauptapplikation.
  202.    Die Hauptapplikation sollte daraufhin die vorher in das Fenster des
  203.    Accs gedraggten Icons in den Zielpfad kopieren.
  204.    kstate ist der Tastaturstatus wie von evnt_multi() erhalten.
  205.    Von der Hauptapplikation kommt als Antwort VA_COPY_COMPLETE. Nachdem
  206.    diese Mitteilung empfangen wurde, kann ein eventuell für das Kopieren
  207.    allozierter Speicher wieder freigegeben werden.
  208.    Diese Funktion darf nur als Antwort auf VA_DRAGACCWIND benutzt werden,
  209.    da sonst nicht eindeutig ist, was kopiert werden soll. */
  210.  
  211. int   AVCopyDragged(int kstate,char *dest);
  212.  
  213.  
  214.  
  215. /*** Zur Anwendung ***************************************************/
  216.  
  217. #ifdef __DO_NOT_DEFINE
  218.  
  219. /* Hier ein minimales Skelett für die Verwendung der AV-Funktionen. */
  220.  
  221. void  HandleMessage(int kstate,int *msg)
  222. {
  223.    int   FontId,FontPointsHeight;
  224.    char  *status;
  225.  
  226.    if (AVProcessMsg(msg))
  227.    {
  228.       /* Protokollstatus hat sich geändert */
  229.  
  230.       if ("Habe offene Fenster")
  231.          for ("für jedes offene Fenster")
  232.             AVAccOpenedWindow(winhandle);
  233.       AVAskFileFont();
  234.       AVReceiveStatus();
  235.       ...
  236.    }
  237.    switch (msg[0])
  238.    {
  239.       case  WM_FULLED:  ...
  240.       case  WM_SIZED:      ...
  241.       case  WM_MOVED:      ...
  242.       case  WM_REDRAW:  ...
  243.       case  WM_TOPPED:  ...
  244.       case  WM_ARROWED: ...
  245.       case WM_VSLID:    ...
  246.       case WM_HSLID:    ...
  247.  
  248.       case  VA_SETSTATUS:
  249.                /* msg[3] und msg[4] enthalten Pointer auf
  250.                   String mit Status (kann auch NULL sein) */
  251.                ...
  252.                break;
  253.       case  VA_FILEFONT:
  254.                /* msg[3] und msg[4] enthalten die Fontdaten
  255.                   (siehe VAPROTO.H) */
  256.                ...
  257.                break:
  258.       case  VA_START:
  259.                /* msg[3] und msg[4] enthalten Pointer auf
  260.                   Kommandozeile */
  261.                ...
  262.                break;
  263.       case  VA_DRAGACCWIND:
  264.                /* msg[6] und msg[7] enthalten Pointer auf
  265.                   String mit Liste der auf das Fenster gezogenen
  266.                   Objekte. */
  267.                ...
  268.                break;
  269.       case  VA_COPY_COMPLETE:
  270.                /* Kopiervorgang beendet. Eventuelle allozierter
  271.                   Speicher wieder freigeben. */
  272.                break;
  273.       ...
  274.    }
  275. }
  276.  
  277. void  HandleKey(int ks,int kb)
  278. {
  279.    switch (kb)
  280.    {
  281.       ...
  282.       default: AVSendKeyEvent(ks,kb);
  283.             break;
  284.    }
  285. }
  286.  
  287. void  EventLoop(void)
  288. {
  289.    int   event,msg[8],kb,ks;
  290.  
  291.    do
  292.    {
  293.       event = evnt_multi(MU_MESAG|MU_KEYBD...,...,msg,...,ks,kb,...);
  294.       if (event&MU_MESAG)
  295.          HandleMessage(ks,msg);
  296.       if (event&MU_KEYBD)
  297.          HandleKey(ks,kb);
  298.       ...
  299.    } while (!QuitFlg);
  300. }
  301.  
  302. /* Die AV-Protokollfunktionen müssen durch den Aufruf von AVInit()
  303.    initialisiert werden.
  304.    Dieser Aufruf muß vor Benutzung aller anderen AV-Funktionen
  305.    gemacht werden. */
  306.  
  307. int   gl_apid;
  308.  
  309. void  main(void)
  310. {
  311.    if ((gl_apid = appl_init())>=0)
  312.    {
  313.       ...
  314.       AVInit(gl_apid,"ACCNAME ",1|2);
  315.       if (MultiAES())
  316.          "Warte, bis Status kommt oder Benutzer was will";
  317.       else
  318.       {
  319.          "Tue eventuell selber was (Fenster öffnen o.ä.)"
  320.          EventLoop();
  321.       }
  322.       ...
  323.       appl_exit();
  324.    }
  325. }
  326. #endif
  327. #endif
  328.